{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "9k8VzY7l15EA"
   },
   "source": [
    "# Final Project - TRON Tournament"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PlayerAgent4 is the best"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kp1DaXSa2Pgv"
   },
   "source": [
    "## 1. Set-up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kcJlUeqplOWs"
   },
   "outputs": [],
   "source": [
    "# Import any libraries you might need to develop our agent.\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import time\n",
    "import signal\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from matplotlib import animation, rc\n",
    "from IPython.display import HTML, clear_output\n",
    "from math import sqrt, log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bzhgO2_m2Klx"
   },
   "source": [
    "## 2. Agent\n",
    "\n",
    "The task is to implement an agent using a technique discussed during the class. Your agent should be able to beat random player ~99% of the time, and must comply with a  time limit of 5 seconds per move. Furthermore, you cannot modify the game board directly; any projects that do so that will be disqualified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is an example of an agent which simply picks a move at random.\n",
    "class RandomAgent:\n",
    "\n",
    "    def __init__(self, player_id):\n",
    "        self.player_id = player_id\n",
    "\n",
    "    def choose_move(self, game):\n",
    "        # Get an array of legal moves from your current position.\n",
    "        legal_moves = game.get_legal_moves(self.player_id)\n",
    "        \n",
    "        # Shuffle the legal moves and pick the first one. This is equivalent\n",
    "        # to choosing a move randomly with no logic.\n",
    "        np.random.shuffle(legal_moves)\n",
    "\n",
    "        return legal_moves[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PlayerAgent1:\n",
    "    # default:95%,rocky:60%,obstacles:30%\n",
    "    \n",
    "    def __init__(self, player_id):\n",
    "        self.player_id = player_id\n",
    "        self.elo = 1000\n",
    "    \n",
    "    def choose_move(self, game):\n",
    "        # Get an array of legal moves from your current position.\n",
    "        legal_moves = game.get_legal_moves(self.player_id)\n",
    "\n",
    "        return legal_moves[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PlayerAgent2:\n",
    "    # default:78.5%,rocky:78%,obstacles:65%\n",
    "    \n",
    "    def __init__(self, player_id):\n",
    "        self.player_id = player_id\n",
    "        self.elo = 1000\n",
    "    \n",
    "    def choose_move(self, game):\n",
    "        # Get an array of legal moves from your current position.\n",
    "        legal_moves = game.get_legal_moves(self.player_id)\n",
    "        board = game.board\n",
    "        shape = board.shape\n",
    "        board_copy = board.copy()\n",
    "        max0 = 0\n",
    "        moves = []\n",
    "        \n",
    "        # find the largest number of legal moves\n",
    "        for move in legal_moves:\n",
    "            new_board = game.examine_move(self.player_id, move, board_copy)\n",
    "            legal_moves0 = game.get_legal_moves(self.player_id,board=new_board)\n",
    "            a=len(legal_moves0) \n",
    "            if a > max0:\n",
    "                max0 = a\n",
    "        \n",
    "        # find all the targets which have the largest number of legal moves\n",
    "        board_copy1 = board.copy()\n",
    "        for move1 in legal_moves:\n",
    "            new_board1 = game.examine_move(self.player_id, move1, board_copy1)\n",
    "            legal_moves1 = game.get_legal_moves(self.player_id,board=new_board1)\n",
    "            b=len(legal_moves1) \n",
    "            if b == max0:\n",
    "                moves.append(move1)\n",
    "        \n",
    "        np.random.shuffle(moves)\n",
    "        return moves[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AXJgzLvdCzCp"
   },
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self, parent, point):\n",
    "        self.parent = parent\n",
    "        self.point = point\n",
    "        self.children = []\n",
    "        self.explored_children = 0\n",
    "        self.visits = 0\n",
    "        self.value = 0\n",
    "        \n",
    "\n",
    "def average(node):\n",
    "    return node.value / node.visits\n",
    "\n",
    "\n",
    "class PlayerAgent3:\n",
    "    # default:95%, rocky:97%, obstacles:78%\n",
    "    def __init__(self, player_id):\n",
    "        self.player_id = player_id\n",
    "        self.elo = 1000\n",
    "\n",
    "    def choose_move(self, game):\n",
    "        player_position = game.get_player_position(self.player_id)\n",
    "        board = game.board\n",
    "        root = Node(None, point=player_position)\n",
    "        board_copy = board.copy()\n",
    "        \n",
    "        ## expansion\n",
    "        children_node = game.get_legal_moves(self.player_id, board=board_copy)\n",
    "        if len(children_node) > 0:\n",
    "            for c in children_node:\n",
    "                root.children.append(Node(root, c))\n",
    "        else:\n",
    "            return None\n",
    "        \n",
    "        ## compute average depth of children_node\n",
    "        for j in range(len(children_node)):\n",
    "            node = root.children[j]\n",
    "            # print(\"compute {} node {}\".format(j+1,node.point))\n",
    "            sum_depth = 1\n",
    "            board_copy2 = game.examine_move(self.player_id, root.children[j].point, board_copy)\n",
    "            for k in range(10):   \n",
    "                while True:\n",
    "                    legal_moves1 = game.get_legal_moves(self.player_id, board=board_copy2)\n",
    "                    np.random.shuffle(legal_moves1)\n",
    "                    if len(legal_moves1) > 0:\n",
    "                        # print(\"next node:\",legal_moves1[0])\n",
    "                        board_copy2 = game.examine_move(self.player_id, legal_moves1[0], board_copy2)\n",
    "                        sum_depth += 1\n",
    "                    else:\n",
    "                        break\n",
    "\n",
    "                node.visits += 1\n",
    "                node.value += sum_depth\n",
    "            # print(\"sum_depth:\",node.value,\"visits:\",node.visits)\n",
    "        ## select the child node with max average depth\n",
    "        best_node = max(root.children, key=average)\n",
    "\n",
    "        return best_node.point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ucb(node):\n",
    "    ucb = node.value / node.visits + sqrt(log(node.visits) / node.visits)\n",
    "    return ucb\n",
    "\n",
    "\n",
    "class Node:\n",
    "    def __init__(self, parent, point):\n",
    "        self.parent = parent\n",
    "        self.point = point\n",
    "        self.children = []\n",
    "        self.explored_children = 0\n",
    "        self.visits = 0\n",
    "        self.value = 0\n",
    "        \n",
    "\n",
    "class PlayerAgent4:\n",
    "    # default:95%, rocky:97%, obstacles:78%\n",
    "    def __init__(self, player_id):\n",
    "        self.player_id = player_id\n",
    "        self.elo = 1000\n",
    "\n",
    "    def choose_move(self, game):\n",
    "        board = game.board\n",
    "        player_position = game.get_player_position(self.player_id)\n",
    "        best_node_list = []\n",
    "        for episode in range(3):\n",
    "            root = Node(None, point=player_position)\n",
    "\n",
    "            for k in range(20):\n",
    "                sum_reward = 0\n",
    "                node = root\n",
    "                actions = []\n",
    "\n",
    "                ## selection\n",
    "                board_copy = board.copy()\n",
    "                while node.children:\n",
    "                    # print(\"began selecting\")\n",
    "                    if node.explored_children < len(node.children):\n",
    "                        # print(\"value,visits\",node.value,node.visits)\n",
    "                        child = node.children[node.explored_children]\n",
    "                        node.explored_children += 1\n",
    "                        node = child\n",
    "                        # print(\"new node is：\",node.point)\n",
    "                    else:\n",
    "                        node = max(node.children, key=ucb)\n",
    "                        # print(\"node with largest UCB：\", node.point)\n",
    "                    board_copy = game.examine_move(self.player_id, node.point, board_copy)\n",
    "                    sum_reward += 1\n",
    "                    actions.append(node.point)\n",
    "                    # print(\"finish selecting\")\n",
    "                ## End To-DO ##\n",
    "\n",
    "                ## expansion\n",
    "                ## To - DO ##\n",
    "                # print(\"start expansing\")\n",
    "                children_node = game.get_legal_moves(self.player_id, board=board_copy)\n",
    "                if len(children_node) > 0:\n",
    "                    for c in children_node:\n",
    "                        node.children.append(Node(parent=node, point=c))\n",
    "                        # for i in range(len(root.children)):\n",
    "                        #     print(\"节点{}第{}个子节点为：{}\".format(root.point, i+1, root.children[i].point))\n",
    "                # else:\n",
    "                #     #             print(\"节点{}没有子节点\".format(root.point))\n",
    "                #     return None\n",
    "                # print(\"node_children长度：\", len(node.children))\n",
    "                # print(\"finish expansing\")\n",
    "                \n",
    "                ## simulation\n",
    "                while True:\n",
    "                    # print(\"start simulating\")\n",
    "                    action = game.get_legal_moves(self.player_id, board=board_copy)\n",
    "                    # print(len(action))\n",
    "                    np.random.shuffle(action)\n",
    "                    if len(action)>0:\n",
    "                        board_copy = game.examine_move(self.player_id, action[0], board_copy)\n",
    "                        # print(action[0])\n",
    "                    else:\n",
    "                        break\n",
    "                    sum_reward += 1\n",
    "                    if sum_reward>30:\n",
    "                        break\n",
    "                    # actions.append(action)\n",
    "                # print(\"finish simulating，sum_reward is：\",sum_reward)\n",
    "\n",
    "                ## backpropagate\n",
    "                while node:\n",
    "                    # print(\"start backpropagating\")\n",
    "                    node.visits += 1\n",
    "                    node.value += sum_reward\n",
    "                    node0 = node\n",
    "                    node = node.parent\n",
    "                # print(\"finish backprogating\")\n",
    "\n",
    "                if k==19:\n",
    "                    best_node_list.append(max(node0.children, key=ucb))\n",
    "\n",
    "        best_node = max(best_node_list, key=ucb)\n",
    "        return best_node.point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6NUESKXu2WQr"
   },
   "source": [
    "## 3. Environment\n",
    "\n",
    "This is the game environment. It will probably be helpful to have an understanding of how the game works,\n",
    "so we reccomend reading through the implementation.\n",
    "\n",
    "**!!!!! Do not modify the game's implementation !!!!!**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "G22Bi6uSu0M7"
   },
   "outputs": [],
   "source": [
    "# This handler will be used to time-out actions/games which take too long to compute.\n",
    "# Note that this handler does not function on Windows based systems.\n",
    "def signal_handler(signum, frame):\n",
    "    raise TimeoutError(\"Timed out!\")\n",
    "#signal.signal(signal.SIGALRM, signal_handler)\n",
    "\n",
    "\n",
    "class TronGame:\n",
    "\n",
    "    def __init__(self, agent1_class, agent2_class, board_size, board_type):\n",
    "        # Default board.\n",
    "        if board_type == 'default':\n",
    "            self.size = board_size\n",
    "        # Board with obstacles and a fixed size of 10x10.\n",
    "        elif board_type == 'obstacles':\n",
    "            self.size = 10\n",
    "        elif board_type == 'rocky':\n",
    "            self.size = board_size            \n",
    "        else:\n",
    "            raise ValueError('Invalid board type.')\n",
    "\n",
    "        # Build the game board.\n",
    "        self.board_type = board_type\n",
    "        self.board = self.build_board(board_type)\n",
    "\n",
    "        # Initialize the game state variables and set the values using the \n",
    "        # 'reset_game()' method.\n",
    "        self.reset_game()\n",
    "\n",
    "        # Initialize our agents.\n",
    "        self.agent1 = agent1_class(1)\n",
    "        self.agent2 = agent2_class(3)\n",
    "\n",
    "    def build_board(self, board_type):\n",
    "        \"\"\"\n",
    "        This method takes a board_type: ['default', 'obstacles'] and returns a \n",
    "        new board (NumPy matrix).\n",
    "        \"\"\"\n",
    "\n",
    "        # Default board.\n",
    "        if board_type == 'default':\n",
    "            board = np.zeros((self.size, self.size))\n",
    "            board[0, 0] = 1\n",
    "            board[self.size - 1, self.size - 1] = 3\n",
    "\n",
    "        # Board with obstacles and a fixed size of 10x10.\n",
    "        elif board_type == 'obstacles':\n",
    "            board = np.zeros((10, 10))\n",
    "            board[1, 4] = 1\n",
    "            board[8, 4] = 3\n",
    "            board[3:7, 0:4] = 4\n",
    "            board[3:7, 6:] = 4\n",
    "        # Board with obstacles and a fixed size of 10x10.\n",
    "        elif board_type == 'rocky':\n",
    "            board = np.zeros((self.size, self.size))\n",
    "            a=np.random.randint(2,size=(self.size,self.size))\n",
    "            b=np.random.randint(2,size=(self.size,self.size))\n",
    "            c=np.random.randint(2,size=(self.size,self.size))\n",
    "            d=np.random.randint(2,size=(self.size,self.size))\n",
    "\n",
    "            board=board+(a*b*c*d)*4\n",
    "            board[0, 0] = 1\n",
    "            board[self.size-1, self.size-1] = 3\n",
    "                      \n",
    "\n",
    "        else:\n",
    "            raise ValueError('Invalid board type.')\n",
    "\n",
    "        return board\n",
    "\n",
    "    def reset_game(self):\n",
    "        \"\"\" \n",
    "        Helper method which re-initializes the game state.\n",
    "        \"\"\"\n",
    "        \n",
    "        self.board = self.build_board(self.board_type)\n",
    "\n",
    "    def get_player_position(self, player_id, board=None):\n",
    "        \"\"\"\n",
    "        Helper method which finds the coordinate of the specified player ID\n",
    "        on the board.\n",
    "        \"\"\"\n",
    "        \n",
    "        if board is None:\n",
    "            board = self.board\n",
    "        coords = np.asarray(board == player_id).nonzero()\n",
    "        coords = np.stack((coords[0], coords[1]), 1)\n",
    "        coords = np.reshape(coords, (-1, 2))\n",
    "        return coords[0]\n",
    "\n",
    "    def get_legal_moves(self, player, board=None):\n",
    "        \"\"\"\n",
    "        This method returns a list of legal moves for a given player ID and\n",
    "        board.\n",
    "        \"\"\"\n",
    "        \n",
    "        if board is None:\n",
    "            board = self.board\n",
    "\n",
    "        # Get the current player position and then check for all possible\n",
    "        # legal moves.\n",
    "        prev = self.get_player_position(player,board)\n",
    "        moves = []\n",
    "        \n",
    "        # Up\n",
    "        if (prev[0] != 0) and (board[prev[0] - 1, prev[1]] == 0):\n",
    "            moves.append([prev[0] - 1, prev[1]])\n",
    "        # Down\n",
    "        if (prev[0] != self.size - 1) and (board[prev[0] + 1, prev[1]] == 0):\n",
    "            moves.append([prev[0] + 1, prev[1]])\n",
    "        # Left\n",
    "        if (prev[1] != 0) and (board[prev[0], prev[1] - 1] == 0):\n",
    "            moves.append([prev[0], prev[1] - 1])\n",
    "        # Right\n",
    "        if (prev[1] != self.size - 1) and (board[prev[0], prev[1] + 1] == 0):\n",
    "            moves.append([prev[0], prev[1] + 1])\n",
    "\n",
    "        return moves\n",
    "\n",
    "    def examine_move(self, player, coordinate, board):\n",
    "        board_clone = board.copy()\n",
    "        prev = self.get_player_position(player, board_clone)\n",
    "        board_clone[prev[0], prev[1]] = 4\n",
    "        board_clone[coordinate[0], coordinate[1]] = player\n",
    "        return board_clone\n",
    "\n",
    "    @staticmethod\n",
    "    def view_game(board_history):\n",
    "        \"\"\"\n",
    "        This is a helper function which takes a board history \n",
    "        (i.e., a list of board states) and creates an animation of the game \n",
    "        as it progresses.\n",
    "        \"\"\"\n",
    "\n",
    "        fig, ax = plt.subplots()\n",
    "        colors = ['black', 'blue', 'pink', 'white', 'red', 'yellow']\n",
    "        cmap = matplotlib.colors.ListedColormap(colors)\n",
    "        bounds = np.linspace(0, 5, 6)\n",
    "        norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N)\n",
    "        matrix = ax.matshow(board_history[0], cmap=cmap, norm=norm)\n",
    "\n",
    "        def update(i):\n",
    "            matrix.set_array(board_history[i])\n",
    "            return matrix\n",
    "\n",
    "        ani = FuncAnimation(fig, update, frames=len(board_history), interval=100)\n",
    "        plt.show()\n",
    "        return HTML(ani.to_html5_video())\n",
    "\n",
    "    def play_series(self, num_games, debug=True):\n",
    "        \"\"\"\n",
    "        This method plays a series of games between the two agents.\n",
    "\n",
    "        It returns two objects: (i) a tuple which indicates the number of \n",
    "        wins per player, and (ii) a history of the board state as the game \n",
    "        progresses.\n",
    "        \"\"\"\n",
    "        \n",
    "        wins_player_1 = 0\n",
    "        wins_player_2 = 0\n",
    "        games = []\n",
    "        winner_history=[]\n",
    "        for i in range(num_games):\n",
    "            winning_player_id, board_history = self.__play_game(debug=debug)\n",
    "            games.append(board_history)\n",
    "            winner_history.append(winning_player_id)\n",
    "            if winning_player_id == 1:\n",
    "                wins_player_1 += 1\n",
    "            elif winning_player_id == 2:\n",
    "                wins_player_2 += 1\n",
    "            else:\n",
    "                raise ValueError('Invalid winning player ID.')\n",
    "\n",
    "        print(f'Finished playing [{num_games}] games.')\n",
    "        print(f'Player 1 won [{wins_player_1}] games and has a win-rate of [{wins_player_1 / num_games * 100}%].')\n",
    "        print(f'Player 2 won [{wins_player_2}] games and has a win-rate of [{wins_player_2 / num_games * 100}%].')\n",
    "        return (wins_player_1, wins_player_2), games,winner_history\n",
    "\n",
    "    def __apply_move(self, player, coordinate):\n",
    "        \"\"\"\n",
    "        This private method moves a player ID to a new coordinate and obstructs\n",
    "        the previously occupied tile.\n",
    "        \"\"\"\n",
    "        \n",
    "        prev_coord = self.get_player_position(player)\n",
    "\n",
    "        self.board[prev_coord[0], prev_coord[1]] = 4\n",
    "        self.board[coordinate[0], coordinate[1]] = player\n",
    "\n",
    "    def __play_game(self, debug=True):\n",
    "        \"\"\"\n",
    "        This private method plays a single game between the two agents. It\n",
    "        returns the winning player ID as well as the history of the board\n",
    "        as the game progresses.\n",
    "        \"\"\"\n",
    "        \n",
    "        # Reset the game.\n",
    "        self.reset_game()\n",
    "        board_history = []\n",
    "\n",
    "        # Play the game until it's conclusion.\n",
    "        while True:\n",
    "            # ---------------------------------------\n",
    "            # PLAYER 1's TURN\n",
    "            # ---------------------------------------\n",
    "            # Check legal moves.\n",
    "            poss_moves = self.get_legal_moves(1)\n",
    "            if not len(poss_moves):\n",
    "                if debug:\n",
    "                    print(\"Player 2 wins\")\n",
    "                winning_player_id = 2\n",
    "                break\n",
    "\n",
    "            # Compute and apply the chosen move.\n",
    "#             signal.SIGABRT(3)\n",
    "            try:\n",
    "                move = self.agent1.choose_move(self)\n",
    "            except Exception as e: \n",
    "                print(e)\n",
    "                print(\"There was an error while choosing a move.\")\n",
    "                print(\"Player 2 wins\")\n",
    "                winning_player_id = 2\n",
    "                break\n",
    "            self.__apply_move(1, move)\n",
    "            \n",
    "            # Record keeping.\n",
    "            board_history.append(np.array(self.board.copy()))\n",
    "            if False:\n",
    "                print(self.board)\n",
    "                time.sleep(.5)\n",
    "                clear_output()\n",
    "\n",
    "            # ---------------------------------------\n",
    "            # PLAYER 2's TURN\n",
    "            # ---------------------------------------\n",
    "            # Check legal moves.\n",
    "            poss_moves = self.get_legal_moves(3)\n",
    "            if not len(poss_moves):\n",
    "                if debug:\n",
    "                    print(\"Player 1 wins\")\n",
    "                winning_player_id = 1\n",
    "                break\n",
    "                \n",
    "            # Compute and apply the chosen move.\n",
    "#             signal.alarm(3)\n",
    "            try:\n",
    "                move = self.agent2.choose_move(self)\n",
    "            except Exception as e: \n",
    "                print(e)\n",
    "                print(\"There was an error while choosing a move.\")\n",
    "                print(\"Player 1 wins\")\n",
    "                winning_player_id = 1\n",
    "                break\n",
    "            self.__apply_move(3, move)\n",
    "\n",
    "            # Record keeping.\n",
    "            board_history.append(np.array(self.board.copy()))\n",
    "            if False:\n",
    "                print(self.board)\n",
    "                time.sleep(.5)\n",
    "                clear_output()\n",
    "#         signal.alarm(0)\n",
    "\n",
    "        return winning_player_id, board_history"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "12TDhvJO2Z-t"
   },
   "source": [
    "## 4. Development"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "fEgq3_sGyK1V",
    "outputId": "4bbe3045-e5c3-4fc4-a4df-847735f6d50b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished playing [10] games.\n",
      "Player 1 won [9] games and has a win-rate of [90.0%].\n",
      "Player 2 won [1] games and has a win-rate of [10.0%].\n",
      "time cost: 53.130820512771606\n"
     ]
    }
   ],
   "source": [
    "my_tron_game = TronGame(board_size=20,\n",
    "                        agent1_class=PlayerAgent4,\n",
    "                        agent2_class=PlayerAgent3,\n",
    "                        board_type='rocky')\n",
    "# default rocky obstacles\n",
    "start_time = time.time()\n",
    "(player1_wins, player2_wins), game_histories,winner_history = my_tron_game.play_series(num_games=10, debug=False)\n",
    "print(\"time cost:\",time.time()-start_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 286
    },
    "colab_type": "code",
    "id": "PlPcOK68-j9n",
    "outputId": "ccd92747-b80e-450b-a685-0a53b6e1c46c"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niviBUP8HNFxLRGNl5mYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x18969b1cf98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<video width=\"432\" height=\"288\" controls autoplay loop>\n",
       "  <source type=\"video/mp4\" src=\"data:video/mp4;base64,AAAAIGZ0eXBNNFYgAAACAE00ViBpc29taXNvMmF2YzEAAAAIZnJlZQAAUIFtZGF0AAACoAYF//+c\n",
       "3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1OSAtIEguMjY0L01QRUctNCBBVkMgY29kZWMg\n",
       "LSBDb3B5bGVmdCAyMDAzLTIwMTkgLSBodHRwOi8vd3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwg\n",
       "LSBvcHRpb25zOiBjYWJhYz0xIHJlZj0zIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDM6MHgxMTMg\n",
       "bWU9aGV4IHN1Ym1lPTcgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MSBtZV9yYW5n\n",
       "ZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTEgOHg4ZGN0PTEgY3FtPTAgZGVhZHpvbmU9MjEsMTEg\n",
       "ZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9LTIgdGhyZWFkcz05IGxvb2thaGVhZF90aHJl\n",
       "YWRzPTEgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJh\n",
       "eV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2Fk\n",
       "YXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtl\n",
       "eWludD0yNTAga2V5aW50X21pbj0xMCBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9v\n",
       "a2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBt\n",
       "YXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAADmBliIQAEP/+94G/Mstf\n",
       "IrrJcfnnfSyszzzkPHJdia640AAAAwAM3Yie4PEXodGq0ldQCqXrwcf9IiG9tAk5MWinLa5f8gj5\n",
       "knh687l+1YE7QiXvg377iSrQWQVoDcuVpRwbXbKpYKTiUtoiSaDoJpV/dMdc7QL7JiPMAbMvaXkP\n",
       "F/KQb2JY2pbsKdt2irWRDtH4BjUhfgqUmt0Iq/HRR8gq2bxRYxepEP/dsfwqNoVP5G3kNiVDQdfj\n",
       "f3fvfSPZO9weZWnFilWGt50FVlKerUK52bySv6p/9G8w+Q2mMt9cHWsZd4+Xy9lprQUMIF2+tfAL\n",
       "7oYlMe7I4hFRYVFYw3TacDYWtdraWftxE5tsXypNO5lMlFaaZEJyAzLedzHWhJ5b5iV2eRvn1AkH\n",
       "TsVQv7oeVbsK2vi2/SpoGkNooxI5wAg7/LGGL9xSI+3p4BIT9Vx8Mdn1kf+s+z8F/LkPo6+CL9n2\n",
       "dvDnEpJcOFLsZpOezWmmXxdPxIXfp4lcVYHoO+cog7pmx7Y7YPY3PaGfUUMagANAFAd8QzH1b8oB\n",
       "7zB5ecQbVVTDJfILmI8AEfG0Ggrt5SxmmRSE6HEEPOeCteDSa98sBrTUHvK2MQFeCTLoevDpklOx\n",
       "yIDxYvDlii7/2LYpNr/xyUVWASgZXPCIL3PX9boLo1tkmVQyVYM0SMxa+MP4wErZYETm1JFcvWl1\n",
       "2cQT6TB9NUdBxXt72Y2zJWg6MCGN0xLPU7hDMgLmjaoXA9cMRf40L2tgtf/HX5K/87FSY6gYMqrS\n",
       "5LGj+9M80gwYzVFWjYipLyRBZZVPjQ5JQDzAzRcahFCcIcTramNaLPQpvAYla1YW/7/HE0B75KiB\n",
       "/qQ2BuVArHKq5F9YDqe69hcQnSelSNJ27QdNYk337jz12ECsrbEaiFsxY5likLCL522Hqo/p590K\n",
       "ERlqDUCufMy4t0WUgMZahflJQhpmotb3Tex2R6Dp5VgW/DF3OA5berE3486jRZueJsy9caX0w8Zo\n",
       "d5U8a9SC3Ogck6JtJqM1aP364X2n1cj11boaoXpuZ/xgQTAZjgDLiqnJki6A+2Fjqm6dgkvKRpsH\n",
       "4Y3rGt4D4DONg1+phlgeoTeHkDcWX+gfGnHh4ptuWUpWLV9mj+uT6xACpb1rP//8TIT/e4w7DVth\n",
       "jvh8292mZy1PNEtGCX3eViGOPr5Zpw0itJitE2wfOQHC6dayLsIsTPBVia5bw5qx+mRyTBawDIVj\n",
       "6q1g+fItF7/UC+mHH8WKofbh6LbiPPNQVKYBR7fOQLo9nSdRniikBZAY0T5J955R2JDrpfzpigp4\n",
       "jLZ8uygjHI1AVkcml4W/HQLwTsZ9tmZm+pEn/x1bS+c8YbqDmLPJENd8JYyCCe39aJs+4mcvGAVd\n",
       "M9j1ElertyAHxAsUn/cvNDX1gr6+MW9+KoZRb3eQ7QObFz/O6cPpBUBhMIq3FJDYWmedHQHAEQx1\n",
       "+vW/ZVniQM7pxOEi50COX0zXBKjtjuSKFnUO6ZcYxMwNMEoQIUM0ygd/bwlxY2d4Bbhurw99V0Dn\n",
       "KINUvxjLryJvX2136cGCU4u02BvBxTly/nvNdh1tGcHnRT6V2kuRyU0Z+BGsr//x5cvyVYkkeYi/\n",
       "U02DgKFFBt+MUGygb+LOtLOuy3YCAAa/21aBPUziHLEw5r0PgUBhtS+RTZyzo2HAT/6aGq99tTFB\n",
       "njFlLooRdMyathP+pSwLA9n/rlg5ym9QlHpkshKnGc/wwao5qroFY4tq42gsQKExndfRGGNUaNDN\n",
       "lOeX4m4ZsH8E9s+lIFWopt0aiqXeazkoV+IU5Tja/M0TuuqEn6PeprCCGzF3FngzijhXROJQsjrj\n",
       "1EsXqW9FQiRqJzTx1SLpB+legwQsAruc1SgUTRjFTtqz7nOQdYvwaGb5rzKcCw8bFALU6N5CMpyH\n",
       "5yHd8UiI99MpdNqBorlrqEzPENtuimrYUp81Xz5Xt4/auBvl6YPQjEC7lmuDYqpbziwpCp8PuqKj\n",
       "/UQ1PgQjXuc5J/H1RZvFl1SaiggwOVm4bbeu8c0qjxGeGXq+GLCI9D/m6tigE1fb1sJLvdm17CQa\n",
       "j1C1n9x+/+ktZOaW9gqKgl49pm8jjiSXNANX9XhPNMLJGQF8Plmq4GzY3yh++UpFtDfrDkAHLGDR\n",
       "YBMaovkK+urGq5BDJcpT4k7F1QPGHKc5aPK+f5pYT/WaUzbz3q+Bd4BWrpYY9ctXIf8JCFlhZVCI\n",
       "NUH0lFPmOVe/7dPRDgv5Lvts4Jffuq7gtho/tm+VPIucwkZGZJYjdo9gwdZbdnewPbcFaOopu07z\n",
       "kVshb4gR5+wKcGnLvEBjXDz0Tz+/wGEBwbdYJeONwBO66D1qykpQBZJZZZANrrO6Iyn+m9KnH7I/\n",
       "droJ3E5mgdMy54c29mOX7GxOBoIIBVCz16281REdS1yUsNP4zra5k1LPf1dHyMWArxMK0WjWo8YC\n",
       "IE66Ko+EY9AODF2Nmcu0ZavxqW7/xIbuOVc3evdzNXECFPtP8pX6uu7zcDlRPif4oysZsS0VzgyE\n",
       "LzM2qzFWVkLC5qkEvbxdewn71FFvWKFewwrdSzLIA+dvx0OGg+BB2hhV9g/pTWVAc/V6RVIuqXtz\n",
       "CpAhOIhvUYs4Wg2zC39Qsop2bGPJjpdAqCa3nJ3Xj+27ike+AgHmnom/pmSHEkfiJiyuXutpQtop\n",
       "PGo6+yYGLvSMCbB4KGoTx8wfCrfBvq0uNFzU9ZYgBCe6gRm09bVu1YyqFVgUbAlJULXArLv3uyti\n",
       "1ikYis1l6RoZ4waQ4+5CfP9tX8jxIO8pSAhVNQvKOXo/AiM8srK5nRmNm2PtXTI3qGThDXXsth+i\n",
       "ChrnE7OBN/ACgrDzapYGbDve2oJtTPI7ZDbgViBXGoyW+7yWheptEaIMhCle8YJh2fslCafN1lna\n",
       "gFRBaHa7cgIOsHFjXQMlaT8SNQoUYy5Q7n4Sdok+SENX9XdYNELrB8zfT30PsI/zeQHQEcYqtqXG\n",
       "FMuyzHO0SD2iPrTvgTrBm6LdQ+FNewUDgL8djsgerGujjHi6pnWdQpZLLNtNd8hIywn/dwpadlrt\n",
       "v14o8IeWHj4NkcQLn8bgAPO81bLEQ/NHrDbtWp1gSLoFrb8tSErImbgVsyW3pfyvDqwSXGsvB1h9\n",
       "TeKzd2yog18ZnA4Mh5wvGpNC2GJ8oi8TTLZAx/h1RrgEkIOCHlgvedzALa0KZ56edjEX8Vjueo7t\n",
       "LWOZIRPmU2ZdAHFbB/MfYJlps8sLbVmGjgLmCwdBNH2auypKc6XVB0hk9OkgAQcmNwqIk4Pa8MQp\n",
       "ps0ZDbWfUzk9/4O38IRG3yXNGN0S0nmStF1t94CR2Fyj1K1Hp29nsnqjIqxXcHgagHTePs8k1t9Z\n",
       "jAfzAXxoscjgniet5RuDeCyjQAozQmAR5dxSyeDXQ5NETYoM6qiBXHKUBCzeeEAa6b19Yf1IZVpm\n",
       "a9d2FTP+juiFSX9AlBMjOKnySBKZN7XCN5mijyTqtFE1uv4MrhPOK7kQq4sM2StCxG/JShImcpOG\n",
       "OJqljFGO4KSCRU7elTuJDnZWmYsZocbjxYQPp2IHv6GzeE5SKQJWsQaFryNLH7W38MQ4vxxyEEP5\n",
       "9KbVgQ6vKNssdUcG4M8cf4a/tEgT1I0JwMYZHhpQb7ZA9nk1CIjA7MTK2PEYoNCeQH8w/LlLXqaM\n",
       "zPTakTeEGNcIYfDXczod4ckEOIO9Vm+rgIieUliNbbO3R06V4G1s43aFqeIH9fSywbM0oi3hwJoh\n",
       "wlO62SSCxFQ+SWdONccNAeszuk6oRheZJzKKxMYlZd8rExjLd9sjuFuFZ5Lb4/4jkaX/OtyCRhFJ\n",
       "C0CZqXR2gR+UhuCT3BNq/pHR4oIQZr+Xf1popPLbNDTgR1cWSrqI8Z0VgdQeF6uNrO8qqeuLnK9n\n",
       "YWNpkHttGLAdlW3wc2rJO/HRmaWxqI6dVpvq6DQXSl6FwApyZcSRYzm1GJF42KlJYOr3n1NZ753I\n",
       "1bOrRoNd7mwN8tPwwQhvQtzb8ranlrKLEA5lSJd/OJFtvVxWUblzmzW7aV9KJPBwdGDTPXE05L/9\n",
       "492U4kONlPulDqxnT3gxBBAZN/YOLqsBvqIs9GyJye/9IG0st21AjuAJ0P3bhrwfPVyPxhe908EO\n",
       "bFyefk0/DFDwFitTzUbFsoKm6vSzpjyaAfROp21USmSmH6JUDNwVNYNW5dYEv/3y0RxzP7WEleFk\n",
       "S67WbB1FfypbCTttkN5rLXdU5toSSrw2fnJOGtLM4rEysImO6S7qDi70bNQuNUFrw1tzbzn08m7/\n",
       "dt+U8Xwn1S92/BB3NgKyBlXWZUmWVBiX29k4SKF5bPX0t+hg5/draiNk6TG6KjvXwO1rGefF2ZCF\n",
       "xOp49TS8eH/GT1eItgTaYMPB3J1D7tfmc5w2PPcLPLfDRvres9Z3C5uTcpNA7F/RHX5/IWCkJTFk\n",
       "jFKR6MIigt7HzB/2mxxLDsgHP4vGFmop6kXAhWNomultbiybXwz0t2cACHl/zRsrETCyPp0K3U5u\n",
       "QF5lW90AVHEoacykePjFojyZLjOv88TJHh/Tm7PKq4IReRkXMgaNWFIbEbJu1fiGCb97e7qR0NnL\n",
       "56FkP909qM3amLqsC3j+S0zhqOciYQ8xDah5WRAXMi/zHN9yLpYlkPF9d5ioveXFYoJrUu8WEhev\n",
       "8sH4WDlQjBPr5IQbAUFs/qxXk0cGA1HRR+/3UUQRVO+Gi1iX43zPFeKQFQ/WUD5YLC5k7cn/+SSp\n",
       "iwp6K2OdszzEFdxmMRoYPu+1/CI4AREtDHGHlippjMSUxOUfX1npVcZqlHLamHdQrfWIyt+e0JXQ\n",
       "QAAHl6Xur12GowE4FW1caA+tj2q6tHc2lEYEpvIx1T6GAF2wpNN2kzzZFbewWOSGhWtoRwIVMB0H\n",
       "+pMTEPhNbzdfYQx+AAADAACagQAAAe1BmiJsQR/+tSqAHMJ1DoABjzxKT4gydsWdH81eKwlljAO0\n",
       "5kmF3i8PVCJ/SzV6VD0vEIfBEkOri5ApNj1/2D2e4f//aHt/xFeDfx86dTHW9/I31bCS5giMjRLg\n",
       "zdjSNTH/P9eomlc5oVm5qMPnp8KqylKEcFXu/3GLlVkdlrC2P3sjxQMKdvyM44ykkOGM/JkBTv0x\n",
       "c0JTDAKaqZ3trj8WM5b/hWijOfAahbQObEMK7KP9lrYr/rad3xcumZP2YWlsVnP3mozw7KxQT2pr\n",
       "2bDEWkf7D9iUwJ/iOooES7IlECjk0xhKw3TMKpkUQ4jL72kSlQEIkWfAeIB+mA+bNJj6+49Ymxcc\n",
       "aV1pH1YpJC2AN2W18dE7Yv9r108OIfl69ABVxTP65slI5XfKtKiErxqC3ue9zWMX8xlsGw/f2RZg\n",
       "lotcfLxIFdrJeTfqFdz3bFhfvhsGab3WkxMWFzP0YhoKVmOQqAG3pKB873rWo+KPOcam6LCVMpMr\n",
       "eFia8yi1Olbpv46KhxTz9lrWIFnSlsIIc3CueTxwm2Be+t4H4nsTYnXUF1hqX+BRFPJCOpAX2I9M\n",
       "Ouivxm7vxlItNMUezEXRNVp/8ab+WJteyeLXxCzhgcj9gmivADMHHnHXACGC+Twzc3+IrN5ODpXW\n",
       "FmVvAAAAMwGeQXkN/wFXhUwjB5AAO0iXa2HWCeNF16/9EhBLO1cQYyMVr83CpjODIGOPWRNBk/I7\n",
       "oQAAALBBmkQ8IZMphBH//rUqgTbZujSx/8ABdpP/Mh5qCnp/jkAzu3rcvaEFJvhlmIuyI/bWCOVG\n",
       "jwtYB7Tcure7dtYtfIV7dqnlv5QzF14I1eOKOjxXeDLUW6tvfdcaIwWUgxvwM7Qt30HG/X01RuYX\n",
       "c+Z9KKKhrDNOoe49WNI9dlVlfe97q4KNo5i16aZ2wW/L4tuGA4G0V/YLsH4Xy3vtQ6HhRxLHV0lt\n",
       "gn1vJsiRpagvnAAAABgBnmNqQ38BVwGNixtYfurFgqdMKRF0LUEAAAF5QZpoSeEPJlMCCP/+tSqA\n",
       "HI+g9TXgDs5LzWA85ZIyIudoXsvQTCcKZO+u4u3OPfIreYYX7ktXYpIguuJYSYJFsP+N0BfR4i62\n",
       "9tJGi3LzgG0GfYkB4//ByD3qkjaCHCslDDNeYQRVNFeeIXq2vHOOwnIK0z/9f0Q3yz//4xAmd6rH\n",
       "ehipII4FEXn/2uA4pGppAM5Ov9gkEfjQG8S00exDwkt0pdKangaWUFPGoOIj7kPWMrZTNlzAl/+5\n",
       "TttvKSy/rPp/RVZGhbITF4AW3P2ZyRqI68wVK866/lLjbMe9vZ+y81x9J08U0IgU43WkLfKjegg5\n",
       "quuKwmdNVdUQaxvPcWd6J7qofPeiL9yTDY1NYrysMoKy8TxysSUIMF/sCwefnFJnB9NFitBkmqn6\n",
       "OFLsOCPSBa3+M/jyUKAGNdn9mm3z3WZocysPmNppQFhNISGdTX/4czoZQIHWN0Hnc9X49EBOdrsx\n",
       "1km4Xe6lXstfO6qYMusMSZ95TcEAAABnQZ6GRRE8O/8AZTY9MUKjqKdjzz2eVABCnDb/V3jURWZ9\n",
       "mw/YUtTj7bK8VxrYDH6Xfs5z3h9NCHUT6LKS/9WcRMh5sHJpQRLmo+dryt9M3BfLjJzvpO+OfoU1\n",
       "SNk4mqHoaCZzcRgPmQAAACIBnqV0Q38BRg1QMhIwgbPCAB2YNafXS5jHJ4MA+Ghd+/DZAAAAGAGe\n",
       "p2pDfwFFiZPfZj3avFWlT/Prxd40wAAAAU9BmqtJqEFomUwII//+tSqAG47oel5ubZaGRu0Qq1/E\n",
       "dcUN1PRlzzDaaHrCXLkd08BlqV0QiU4U6Za5aI/oaGQ90Q5DnJOn6rzSzH0Y/51XKqNDZUHV8i2+\n",
       "dN1s9X9v8HgRlEsVN/18rZXn5h/KBjnnVoYZc63z/UHKWv1kCBX/BagSD7EcgTMDtL39oeXZelMR\n",
       "RQdWbT4+kAQxjPM9oTUwy7BqHSYYPdkY2frGCzX1qZWkf6kg88wd+MXt9E3sVzHiL+1xQ26BuQq2\n",
       "7ce0cV6eHxuCQtO2AYPNWH2wJZINd8+7Dv1qIxB40QgL0Nj6IIrKO4p3P+k6Yxux5luGrBxHx9Sk\n",
       "oHB+Lo7JUJhKXf9FDGZXwTDvoIffPMg/p0J4tR8Q6FUmK9Q7I2H4VE1WFsQlfnBTILSSpu/rMsBe\n",
       "R+/csDnSWomeG1LJwHy5Cij8HwAAAGBBnslFESw3/wCK9cPcAITOx3nrdecs9VeiXtmDuaaCYGZx\n",
       "6gM2Tp9R9qp83v1rDK8f7/YiiH+A0F/bGn+B9Y20hyrAn/TJuaOhVYbyFMXwIrErZfduf60ERSs1\n",
       "EoPimeMAAAAZAZ7qakN/AUWJk87GyftwMjunZmAVfvnOrAAAAPRBmu5JqEFsmUwII//+tSqAGkO2\n",
       "C9EAG1UfknoYHKR4MkxlXue/YNeuXPovlyKF8GecaYaaxdKosPSKnn/PZ/4CFNj9fk1jaenspK6J\n",
       "2dFjvO1ozqBACBGyQ/C/Wrn1HJax99RQE0jlgQIv4TGxtCnrVdz8YP/PALN+cOgJD1TnwEMsa+AG\n",
       "Moj+mR1D1JpmEH4S+2wa4jRpm0FN+7yjTZCq3lSD7CX8Am2VTE6iss5tnh0/jZhIke2ZfQE2wUqQ\n",
       "NVxdFl8wrZQhLUGaN8OlPsvHCfAKUY1h9PcCi2/zgxaLE8eH/wIr3TWiaHwJTAyDuhEkEAKsAAAA\n",
       "Z0GfDEUVLDf/AIdAH9bMAD+htNvz42ngWbeneH/w6Bf87mFlpAB7RRG3zNXn2j0w9X+0vOo1Xuxw\n",
       "XKZCVV/W2PrfDJ0jFXNwZNMUpe0J/FxiVPMKI6LKtQGLSnyQudQG86ExVKGrqYEAAAAWAZ8takN/\n",
       "AUWJeN/ovZISOdF9u1c1gQAAAP1BmzJJqEFsmUwII//+tSqAGkOx81+cZXx8UCn5YANpR9e8xY0R\n",
       "gpEc0Imy2G6/1YU/XkiqbDIStDz9gXxnzPlsxdcy0I321Tirp/c0BNqFYHnlN/5ubDkT/5pYyN66\n",
       "G2kkRpfxu9VtPPU+WK6EFLCXEdIFQxvoyA3XhThtp+wAUOStRx6e07T1IoFpH0xXeI4lLT2iVG39\n",
       "fyJTk0DBqmPpUMXg0LadMmFUtxbUx00kcaKcCrkunh/g2QZzmfXPfQ3H9JAJ2FCg7F5VGu/LGZKC\n",
       "nudvJw+qMK23RRf4MpmTYsSnEgYyRutHZqOgWwbVpUmx5w8h58aD85d8k06xAAAAlEGfUEUVLDv/\n",
       "AF77fhRQATjK36QbKY4dm7almocr6jksrg9Qmo7/ZrDr3JmL11//B2zla8SWnbppDXD4GcRuAtLC\n",
       "Mji3Rt3jeq7UibZkcT/ILiJrYLLoXCs/KtzAeHRqeoMPf502fitAf3QLcuHWciTIuMRbFt8aDFxE\n",
       "t+3AuQdprXNGsJppeHFHVk7V1iDMjGR+EeAAAAAXAZ9vdEN/AIdeIuLd+Cm0wLv0UkqxWBEAAAAh\n",
       "AZ9xakN/AIdXoBzquCwG7QdE3kEAA0U7HpDuw22HUivxAAABBkGbdkmoQWyZTAgj//61KoAZRW4G\n",
       "OEANLaxcVjt5l1vkH9LJ90Ds4oz0SGNRy9wwP6vA3IpS+wk7rIKfC2Id7Ik8oj8/dp8/DtKftx9G\n",
       "h/eF6gFSeos6171xg748re3SJE4rr//ssCi8pwaOHYxgtvhSzewAL/zddH3AyQzhGdVkIKhc3hrh\n",
       "bb4HUG4m0w0SDmtWmmuOEdssDCMKcOs9At7kWgFJkA3ggxXkcHOGym51h3DScAmApFuKtJKP3w/c\n",
       "vKnkKACizMOT+OsopqHcBlcvbJvIYOmrGEf8GdnhdTQcpeQLdrNBou0Yq323wRbHWDEK6BCyUZNM\n",
       "JuUaWiyaqEZmIVlUOdwAAABpQZ+URRUsO/8AXK1R2Yj010uAEKfRhj37897y3oQCu82UFahrl94c\n",
       "5DcCSoay9GbM8qDBIm/G13vgh+XXjgqP1TeywmhsDWYKGUDzRTQIN0zKSWj2gxK4frDzcdDAPESp\n",
       "DGCvSvk+AANKAAAAFQGfs3RDfwCDXiLi3troB3X7B/hXwQAAABcBn7VqQ38Ag1egItSCSqVpsGds\n",
       "87pEQAAAANtBm7hJqEFsmUwUTBH//rUqgBhVt9MsnyhNDYgBO3yQ00c8vlShT5PBQxRlwE7KO+5P\n",
       "X3beSnX/zxnjNIAM1ca2O4/PxWxnP/NcDflpmVad3xtkEWkgtp6ECH6zcInnCuNo2cXlFqXEiyQv\n",
       "xjfVdLRfzIKeAmw1HiKNYXoup5szDA9EbwSmrpHOMHBD3/DuIT9dDHPuw1QQwRoBCspy43C6/Gv5\n",
       "/Y2EYoy7emrS2dLY/VsxEB3qKeR7r9rlUXrWET7AaHIMNPYMTxc2WD2XkDI7OqPCEOIMuwtcDlEA\n",
       "AAAWAZ/XakN/AH9XoCLHacD0H4fS303c0QAAAQpBm9xJ4QpSZTAgj//+tSqAGFzw9QL0lgKmzZ9u\n",
       "JA9AAS4PephuibSWgf65Z+poFLrUBUtx6YvUqu2Hkdhvs4DnqppLxKeI3YHMxM6FDzOlktgTm1ZK\n",
       "OPOsbydjbkDE0aC2X/YBjQ3k/gPjYPH/9O0xK8Jh53DHv8iK1PHq8gCjLF7/fdkgDVj7WxTRIRDw\n",
       "0XL7/9p4WaEDIdO/KZEjuBFAJeIZ5xam5GNWUdPPaQT/oTtl5ZOJCGhKUtSkGn03j7YIVlIArH9Z\n",
       "5wuWaD3OkBiikhzeh1bi9RJf2ymAiRFJzB+AldbjKufiKmAP05cVFn7/0GG/QDaHSsXOjomjHW3M\n",
       "xB0NmpymFrfAnAAAALNBn/pFNEw7/wBaen4UUAE4ytseYxvlsGb5tXmUXRok+8ec3L8V7ubLuQgs\n",
       "6TPA7AABIP/GHcid9fm9j12zJ//18xyWabIcjjro1kz5vyG697PnBRGIuQJbGvcdd2PMLGP3UnzS\n",
       "oTA+p79TjUC7++yK/8QP/UYo6hZuG1UlcF8UQPA8IWeyRLb8nwsmVzWwpwiIltE7aSlq2LON6OJf\n",
       "m0injH/konb7NS40T5PG2KtfRA8ogQAAACUBnhl0Q38BGtkHnQ8AA7Sfgz4FgVV1ggV83LUPmPI3\n",
       "JErhg2biAAAAGgGeG2pDfwEaec+X4wTB7u4bmNk/Ff0aG2IHAAABC0GaHkmoQWiZTBTwR//+tSqA\n",
       "Fu6tCRyHzsSR+37K+3QdcFIcbf/wSsCVwyv97jVe8SzxHMaSEF0upapq/9+MylTTiLpymBikboRT\n",
       "gI/vBRSiPAHRjPSbTWjFKOakpOL/cKneufv2nZoGis7iuaS4agGrxP4anv+v8s8qjmTw137mppjJ\n",
       "D9t8Uq2dlrdiezNmeZdcmZK2HXzsVN5e0a42/l/rY+E3F9w5K3BNHLeziVEijJZaQFv7i67298Jd\n",
       "cwQebarKn1H/GHwlZgKoiR6s1UxVkKmS53T+MJHs4tsQ18Fh4MWfvkKeRZEE+ofBpwbQu5fqlL4l\n",
       "VE4lKxj5yvVY8k2BQMbcC9gWoBTRGQAAABoBnj1qQ38AP4UIDnVcFgN2oAgvD1npabbpUAAAAVRB\n",
       "miJJ4QpSZTAgj//+tSqAF4bdcgAxsMAeimiAs4B/9skfUJiiTmU/MmMVlNZ3UJNFCTPQz//rm8aU\n",
       "xFBpr3ubWOGX8FykJncP5VGs6s1PD60TPifY1VUi77aQB1Wi30UnKg0m3M/ng0ZnDaJ3zcP27YSl\n",
       "eUsGnpdXui+D4pZQMDNVa5/tMEEvYP+KyuwTNI34VYntqae7F93Pu33RLm3wO9HtOHyQd/baiHYG\n",
       "/IP36T+r0NKDxlaRZRYFy0lwt5OlpH79h9ehJURse2b8JEirE9ClNu/Kv8YrUaJ5ER1v/Gmdf4Zm\n",
       "XLE+Smds4VcHakTmcpJ2L67oD7IkB/94f8/o6sNh5P2+US2rZLU82dN+uILZQyxyUoOqJIKDv5Cy\n",
       "dx1oSWSFPp3PgFe9z3Wpo4uv/Dy18jyr/DBfvFKENVmQOzAGDNNI/hvyceiJ0RbVTSXTiv7sAAAA\n",
       "WEGeQEU0TDv/AFlVlFABD6sle5xHBDd8Pmf0GP+qHRJRI4cj7ZRfLnV0rYMcHVy8gbSocoa1Oqj1\n",
       "0Iq6D8rRRtLLE76Jkr2xiS6OfH3dN/nWhtq70kaFfIEAAAAaAZ5/dEN/AHwPe2alctPBKZa3Pcl+\n",
       "7ktEr1AAAAAWAZ5hakN/AHwKECItJb1qmez0SKxDKQAAAPtBmmZJqEFomUwII//+tSqAF695qA/x\n",
       "0pVCUAFykzJKo9ef///Mpw8zYJsSyF4HOaUP8UZ3OvzV5YCEhhf+8sBcSLelChD2JOUkl1LA1Kbd\n",
       "FRpLT/nixl6bJV328iW59HQUXL661nADHNbNa1JZ/wr/WGYKxqTYNYV5VuE4JTOatcLfbT0hq7IV\n",
       "ILzqGvGb+LMoym7YDQLHjxcJjF8+cYmv/haTw+yJBKhg02n/8AZAk3UoeP8dLjxb4tGbYg+zrmKq\n",
       "zEQDdMfUhscyN0JBaqdejfa/Bxsf0GTf+xp1YhXBs6YCn/vcogLU0meQTQEY48w9qh8h11MvjHdH\n",
       "MAAAAHtBnoRFESw7/wBZTArX/YUjLGerby0AEJRe1dwY9uqgmmn4/0Kxa0PTf03vaMyFZxq5/Hvv\n",
       "B1krcITr8JEZauqq5nqywhp6v3tKOdNivzHHcusRy62GHhtogmwHqrRFB2x/ctAzRCam5fZ7fGyQ\n",
       "SQTFXZilbBO7R/dxuPkAAAAVAZ6jdEN/AHwPe2ZLC3y7eZcNWoWBAAAAEwGepWpDfwB5ShLfMQ2I\n",
       "lBSeg7UAAAFbQZqpSahBbJlMCCP//rUqgBbB2vBJ96AvSAC6Wicfp8OmISU5JaKka5sT3V/WXGXc\n",
       "xiD5RoB03NKj9O3Tgq8ZeFgWt+VbjblL0msj/HmSsDb7roIunr0pwCndU5UmrPIH07s50WnkTsQb\n",
       "1T6NVok772nfu+D2H55MbfOfDReoZY8mG3QutyHN/z3SfDPs//O4MViga2HyPx9ao/SEguzF9onm\n",
       "MPUyu0RIETrOD3v+28vW05YJXr9hhCd+en/lL8TiQcUAe3STD63polM9GmfRxTV8vtPp7VCPV+0a\n",
       "Hun94AJELPhGxcC+lXJMSPn6r7C1YNgnvxDW+FQQ65+m6ayBJqM7luZ1zRwONEPlKHlHVwHcIe3t\n",
       "V+Lnfx/pdxj8zmbTM2ruDYFdviIRsLjpdotDi2garjnnAdKxOHvZlWbmjprAbPvdeTyJEZZ7bqXH\n",
       "aOfyeVTDGsYfxiKZvxMAAABFQZ7HRRUsN/8Ad+LWkAHBd3BPMb4kiZrshPlRxoP9DLEyN0aQavtZ\n",
       "d7rgekFWGn8I7ZvvxkVMkECE+YQOp4KupwsRj0yAAAAAFQGe6GpDfwB5O1hoFFcQgD1y97+vwAAA\n",
       "AONBmu1JqEFsmUwIIf/+qlUALd8T5kePmAOKxKyfgnEDgTW4gKs+jEI23E96qQwGM72taa6+fh+9\n",
       "TYE3j98YKBGs3vwe1WqMQpURiOFgJizZyIraIcGT2NwuuXMhPwwXDI2aFnBU0KHZNfychUxgNoec\n",
       "x6UHOpujed739mM7XtYFkNrZ7wN2kdqkNIyPeIrWWJBV5/LBfFgvx+78L7+v6WZ469wCSbowKcWj\n",
       "Ray8Q3GuS3aEP8mkZezznRCRhZ4nJXxCvrWnKeNGCWSkJLRLKoOMr140Oy/BuyosihP0LmexhxNJ\n",
       "gQAAAJFBnwtFFSw7/wBV+mK7PQAbSjZ2ljQJhpJaOc3QZ7NkYte++dZyOv2BR6xBQ847CjxNeYpb\n",
       "dsDfP+v1V1uuFQHQ5fidqrsUn63VvM4JNv5Agb+3Jyjtej4/k//CHmTExoTPQc6f6Yyud0YK0E9Y\n",
       "ylWVocRLKryn5yAj/5yvHAatTKprilsXWipIJK06z2z07pxSAAAAKQGfKnRDfwB4akGiAA7K5/yo\n",
       "M2/aS/DD1cjPo7XYSI9kggBKxKpQhEvwAAAAFgGfLGpDfwB5O4W9bBf3mLtYRQCR5ncAAACBQZsv\n",
       "SahBbJlMFEwQ//6qVQAW/3+UUkTGABkczX/0uRmlPkTs87k7umlrkx1AAF6TV1r9aTKxxbjNkL9i\n",
       "CVLbdcHa92udm15yV9P0kz0AiK9Vwhk+Ny28Jdjb//rDtOx/cA8qd8s8Q7Ly08cniUzB7WhGkRGd\n",
       "maMOMxDwExW5W50dAAAAGQGfTmpDfwA+IAlFjR7cmIzc+f55+hBsOycAAADyQZtRSeEKUmUwUsEf\n",
       "/rUqgAs3zj0bjgY1Ar9iOugPLq6qFBU7mS86Sn+sHo6ZvqmLBgrN2Y1xYsGM/w2MP1+WIr8Fia4d\n",
       "PEvX03B9CncMkvaM0yx0KJZEpZmAoLfIOD3wS0WQuarnMX8LeYZt69OpDbPDuxdeAEz2DQ23ZtO/\n",
       "/osU14hZAscCiEZmFfjEmw4IcTo6VE7S7yt/NqEv4QLuV6zyGIMm1TQRuG73tIwJMM7lRT85cXsi\n",
       "2MgckGDtUyHHvbTMt+/HZsphwPk89x73VoOR5ZPSv6bP+zaq0yPXn4LKyBCQWKA7Cp+tQdEp9AYP\n",
       "soAAAAAcAZ9wakN/AD4gm0WNggvneI6/ozl1MxK8dyXZgAAAAPJBm3NJ4Q6JlMFEwR/+tSqABdup\n",
       "Key15KfZ2kgCLTGLi1SeCYukwaeV1zDv9uQoreiffKeeTrV2nbKv8Jdf1tS+G64Q22obw9h3KlGg\n",
       "X98GiRW1530ugTM42cI0C9tL0Khq/t74VGnWPFPeD7BEkzewibkj4RuJ4UDV8QCRHuQrCt//FvWC\n",
       "2D/j+6q/CFLVXOtLBnz/o23pIEPTVrBVYGQt5AVV4vA2iFbgrphDf/ZuH+XgZOqCt6oPtdZ0kG0p\n",
       "2A6d08e7tjkPWC0zbpH/vA0ROnqrhU/wjxTmJ7lBcxHSmTd16rSTXJMNcADz8Or+quc7iQAAABwB\n",
       "n5JqQ38APiZ/ve0rByhCdII+MLU8l9vT1lrXAAAAy0GblUnhDyZTBTwR//61KoAFd4ih3j22SACE\n",
       "wMXFjuOgw6sUW4iO7P9UxPAyVBp2+ywl68FSIy7PXRkcMO5UYG9V/oolMcDHeCN9aBqchaOIry9l\n",
       "tYf/5zQIzo3FMMdwpyXcUOAhi/fgptI6ZaTVm8r8Iqbn9HaHeNZlvs1o+dlqgEe5g3WKC79CgfDD\n",
       "oC9/W5mPScc7az06lWU1hLGHjjetSpuJnoDIeON7y6nudcmindYWg26E/JCyoiQgtqVY2GoiqeRa\n",
       "ekq7qm1AAAAAGAGftGpDfwA+Jn+4Ovr4rJ4zxd10AR6rMQAAAUFBm7lJ4Q8mUwII//61KoAFmlKl\n",
       "9WEq4zoiASpRftf0JVnk4TNB7shDK89QcIOGIMNuFH3xaFOtkZc5Tdf0FBjVai7UxH7xeLgbF7B5\n",
       "4S7OWu3M8SAVlVhdp7uPjhhsv4mUu9x9bbxQXUPz/8RWR8h8Jqm4bghV0F3Ek/snXR0n9QkSN93N\n",
       "B1cQbUAA54fPMPvv+V7KjY3YPjXJecc4LoxmGwazoXbXQJf2gLe8y7+5MbzpcmZTPUwj8aq+7Ihe\n",
       "P/w3/A9UK3IEoWQDRsWwrRMTa4HN1G9PUf/eFKFcXBg1AcPC0oSq8pLKxTmGR65f3Qz520N05Zer\n",
       "HoJkRflEV82+DNj4nniaNdDwd5ZHDp3oN/suUaFs0qsGGEfp3BC95U/mQxS/1fNdSr00Yx3thW22\n",
       "dP5Dl71Vv1nKrMCZ+RNOvcAAAACfQZ/XRRE8O/8ALKt/yQWM6ACIPUAY6tY81Q89HUW4mI31RHSs\n",
       "W48sJm7fafdUSrTRdKEHkP95ULfYUVGsXV9zhYdnk4s8OWcNOhOQ1d//rxfcD0f5rwIgVCf04pEV\n",
       "e4lGnCd74BDtTQklTFexdhsN6PdEff2SBbqHO3iE0wCfM6bhYPf+X3P8rXlCM+5u9IZygYl21fbB\n",
       "yoN3Hi5x9leRAAAAGgGf9nRDfwAeXTaVWBQuCIFAyyPWDvnnjfB3AAAAGgGf+GpDfwAeXtYaBRU0\n",
       "A7w0Zj1TOQqbwl+wAAAA60Gb/UmoQWiZTAgj//61KoACymx3ExNtTIzOpEALKqR19b1IpMeAUQrD\n",
       "sabhsKs3D9gd+sSHi18jW/rmZGGtT35wlLqndWebBkxoQLyZeacj6W/tdZm9DGcnKN5qfbvA3jVT\n",
       "t//HdoanFVm61Lg+Ft88fM2qEPYwrdXbQzzkIKiKlVCRXUm/qWCt0breJMEMjHpRi8XU4ZI6hrzN\n",
       "mO40z06BEgwvr/pmyFZEDDYLbEDkIHkF64HZxeBQQdNibW8ToadBS9dhRABDiY0edwTMHDK4TFYU\n",
       "T3QpXG6TRZfZ5p5oafptw8SQEj1Rt+EAAABiQZ4bRREsO/8ALK4YKsF0qM5vwAEDwIBKP0uOcQ0B\n",
       "bnoBBt/ZDm/6AXyusyV7/321nOwiVxR5/fEX5kEss+zkqKgpzl931RiCh2m8QfvlEF2iPqpM9pO+\n",
       "r+hq7xZCnSy23UgAAAAVAZ46dEN/AA8um0qsChcEP1kuI/MtAAAAFAGePGpDfwAO12sNAorjAMeC\n",
       "PZzBAAABGEGaIUmoQWyZTAgj//61KoACym5/CDdLchZ1lFCP/IAFUAxcWWJrDAWDw6AzEAGgxwwq\n",
       "8Q7wBmev62o6di6GirKnyzC1fwUJNzivfQ/oBjeFvQ2IWZqfrOIqpH8U2GuvtkskjtPzEJ8N04E8\n",
       "rxYcMCxuL/BrybQZuxlfcPJMKcINjrf5tAU2Z6//WKKHsYQlMFsu7UVj1hox0CmA8phl9BMeZXIn\n",
       "p7jRWUqVpkmiNjQY80V/OGLOjvtOCd6PU1fLzMqSIneML7Mse0aPfnBExRDjYOC0ytP7cjyuXByT\n",
       "T11FGRUBGd/zw+F1iKSVU0R8JdZufjgJMNXFFKMozbYJkR0E76q9GSxJhznGu31nDvcPwFwII87Q\n",
       "XnAAAACqQZ5fRRUsO/8ALK4YHrZOEPh+IAAEIXA8fKe4x7Nfm9R91lCkH1HljGgd2KfUegBXc5iZ\n",
       "C9MRCPVcSq5WVRyTwrdxx8z8DSE6ht7iULp8nlBwKv+hQx3alzs3PIUqttF2l8UlYjZyXMJRHmGf\n",
       "heL6XxLkGko7o7WIvJbVFaGJ4xhqpCv4bu77TZvHEl/RYy10yXC+KXyWV0XWMmM8xjXljQo7aY7h\n",
       "8mvB9BIAAAAVAZ5+dEN/AAdrTaX6CeIIrSrwP0dxAAAAFgGeYGpDfwAHa7WGgUTOg+9yR490jSYA\n",
       "AAEpQZplSahBbJlMCCP//rUqgALKbn8IJT9HHNwkIIAqL7HsHFzYNRU3qcSOK0oNRqQLi2Wics10\n",
       "EcK3Y6tkPr/VU+Hm5WWWE0GQ7b3Q2jLqbCdqvf+wjyDcTjGxuL/y+1KwvFhqD9iVEaZXUQI2Y/fY\n",
       "ddUkwcO6PQpabGKKewl4zljzHge1prIlNrgMsVIZ8NOf5R+fESDTUj5PsSKR2AMq6TzFp+w6qpqh\n",
       "VXCc5kZtZQmuwX8PrFlHg+sPuQKWzAdMQxptTWkrr3HM30Lfpj2yYFiY7PImQ+SQt5R1V05V4akH\n",
       "oLGzasmomtfrzZKttHXD5AcGBZnYpoScfBXxjDlyZv0iJy7FB9G4hUhaJSgldCrsT3iDOPkyjVGv\n",
       "2PNhn8pdTzWOjQuJUyLVAAAAi0Geg0UVLDv/ACyuGB6QyEGEHp1LTkgAhtNBIw/E6UZwrXMIK0xV\n",
       "1rdIh4A5w9HlzkUk9iM3q+WCsE/xtKclM1rQ84+y9Ogl2VuYAmxg+ZQZ5J7TwGZk6RDIo0S/7fbw\n",
       "2rvHN/t7O0cJnwvKvke7AWfVOa11PEXRyYLszJbijIJaGEFA8hbqpsazLGgAAAAcAZ6idEN/AAdA\n",
       "GdpoUvnUF/afFcDz6XVTpG++dwAAABgBnqRqQ38AA5/aLHF1yiOxqZTkXZnif98AAAC/QZqoSahB\n",
       "bJlMCCP//rUqgACpbKL6Aa4dQKAHBPDm2p7JKElSufY+pnPZpu6nVK9MmeK+xFKBBk5dhKYJWLL8\n",
       "dfR6ny7ctCiK8ddLgw9Ojn2tAltG8bb7+rN/yr20R+EA/lOjgy+l/Dk/HZ298uoB5B0WfPQjijpx\n",
       "pqSnsi4QZl4AVjrPP0im5J0O0WDAVE////3ulH94K6FNlBByEdvHuuWPgKcASVH49mbMPh+7hFCj\n",
       "94BGznaQV6hsUa2qUoEAAABKQZ7GRRUsN/8APipVQQO4fAgP1J3jcAJljM98SL/Z/ZHdek81/uuQ\n",
       "slVBAEozJCEOc98JHJJZMN5eaU/rVe7dFggtZGu5v0mGwFsAAAAWAZ7nakN/AAHQKECJF8U6sMRV\n",
       "3uWMwAAAAPdBmutJqEFsmUwII//+tSqAAFU/tbQAft9VJNRT+oXenb2LPTxMwDUqEF97hiAcGKDV\n",
       "FVybdDFPU1uAM+Z//M9sFiUChiZYkm3w/+0yBKCf9/6hZVQ3+fP3EaiR/22Ilnq//jCAUAhI5xFg\n",
       "qqY6Lxb6tqiFKF6bXXjpqqNfWZ/cLIEE27p6Kd/8wB8V20hOxzzEOqPXO7NdZdZdhqlL9g033xTz\n",
       "4nsuVLi/AOQZiG6rZnDjGBIeybx/6Wg4y3x2P42KZOniegUA2l/Ed1QuPRiRabQiZYjuMSM++iHw\n",
       "W1diZaVDG7u6ziC2/xBG3b91QCOYrtsxTQRTAAAAQ0GfCUUVLDf/AD4qVTyCtGxfIDq26QeAD0AE\n",
       "4vGyjLDr8fyIUSWaGgQ21XbGhyXsz/5GkQ+4e4GRirYw7UYzbqkx5UEAAAAXAZ8qakN/AAHPGgNh\n",
       "2jL/oJCB1DM2PikAAADaQZstSahBbJlMFEwR//61KoAAVMmr0AJKQCQHpdNHzxWqHOxC4yPE9/EA\n",
       "Xb3dBfbiFSGrkLxpbwFU18LGm/gLzGHPmAdyyggJByKN7B6hhRrfkjq7vJU+pId9fWyDMEEHnH26\n",
       "ZiIov7Q3P0neH9G2+6thcJM11STzNK/5XNs7vRO7WzrDi3v0TbmK7PiJtW01zbBjUH1Dghr5wOcE\n",
       "AaBuRY4C6DodNJz6K/el4hDFDI1/V0mDvzOkgH6CJBgO4v6IvP4PJ0IVnS2QsA3flSmV4vlau2aB\n",
       "KjfAXnAAAAAbAZ9MakN/AD4qVTxh3EHVfbxa4QxGYaGIlFLRAAAAx0GbUUnhClJlMCCP//61KoAA\n",
       "oXEf9GVWWVgAcrJtQ6LZ0jJ9MYngEC7BaKSCm0pMxhSxBAx+wMgw5Gbs1umEcCYVnJmzEkInBndX\n",
       "94GFmutd31MIaqVX/4dykDmPgepZ3xw/bN/kB7B7IBUrza+5D+bSwnz5v9VKLNMB/Ek7n+t8O+iV\n",
       "E34Qw1N5Cy6GKlFOemS/88yWVLxGV8aTA2faU+TG+tFDFU34f6f2y8Sy3JxOxxcwjGYDTSJC01za\n",
       "66+mpfJuFA9PeoEAAACOQZ9vRTRMO/8ALKxcGMHrEv+EId8PQHyBABtWH+az4NeqnHrMIDl4oIXZ\n",
       "VjzQ7bXHOG/dsN8r7ohIQxKP4/UwOonrhAYUIa4H9Gmv82Te1iFFssbSpcocGT1GKz4VkgwNREj+\n",
       "/aZlsfO7wzBOGGbXN+uTqXCMbQ7L7YOzZSvJwTy0ByNEcgbktN81PhPPfQAAABUBn450Q38AAcUG\n",
       "dpR8tkD6Eh+9GWAAAAAeAZ+QakN/AAN0AYXaN3CashICvKAC6jY1PPZcs6gOAAABJ0GblUmoQWiZ\n",
       "TAgj//61KoABSifpABYKrd7h4Q+U4scN4Q8GZw/+vNf7swza+FWrNasb7tQncn7wRmxc//BoAGr8\n",
       "ZH80YlSMpX+N85F1TYKoflsFysy5v2xOxuoBdjp616OjHgy/CXE4wVP88tyRVBDfOFRIYpStnPaP\n",
       "mYUEPGmdr8UF2LM65HficRMYwiQYmUQ2DGZ6LEqaRpz/6upGUji636qoK3nRfiJ4N9NWB1BEZgqJ\n",
       "spjRF1gAtmpv8bEx2uJ18T3H+Y/GUmo/KY31nDX+43eVIxmhL7K+ViTrni5aCp2/p5s5u0QgVJX1\n",
       "u9k3NviHbw3QQUba/QfmBYZxKXj7GKNpKbOe09UNjAeND0y2OP0wcjSC54LQwcqHtQqYpRuqgZJJ\n",
       "bbUAAACjQZ+zRREsO/8ALK4YHkvTt5hICACErkZ2DxWb7o4v6Tw/QNzibUuLKMq8wbs97cVk9wf1\n",
       "FV4CMRplKexYc9HXzGf7UD0yI5ePsp4rSareso56ZY9LMYKl8+L+iyCLUZSZaRx10pd5g21aWCAz\n",
       "0s6E7vogTWHMx9QpYf/eyK3KmlnfI3w+UnQC1/HHeKL6TldvhLY2e8ZbTiSuMycUyo0jKA2NnAAA\n",
       "ABwBn9J0Q38AA4mm0v0O25naqjcngWZqw6QjWMFgAAAAIAGf1GpDfwAHE7WGgUTOYW+0LrajcngW\n",
       "bZ2CbSSTb32BAAAA/kGb2UmoQWyZTAgj//61KoABU9XsoARCS0uGnLdWCaTRQLoRA6ERDKs8dvWP\n",
       "f/tWKakRpx3WAhN8kC6XunVIY3YpVP6lJKVErT5mWTd5Bsl4tMYUdabb/ZsNsj5SI5zpQxsjy1x5\n",
       "pHeQ4NjPSe/tsonem2dVJtvpgbcGbI/Z+f1bgUCccRGdOiA6gDLgH//iExwtCVunShmPYDRV9gkc\n",
       "71vodQH7YycmaWUUizEqRyQVJicb/DjayC80okUwYRsyZo58rDsgP4/M9uH0KGAXbQUQFtIkRmc5\n",
       "WjR+c6OzL9Km2PADrDGMboqiBbM2csTWHDPLkcNgbbQncXpLHso5AAAArEGf90UVLDv/ACyuGB6T\n",
       "yWAAz5veS4T429YI4Wh3+YID4hsZc5/uAXMvF0AzaXqm/VhHgRwwkGkv90xWscd6o47BBBQrzGLL\n",
       "3g+h+SK1dWHw9Omre4je7U3k/glO5xPgucClUJR6Aclbjz/42DOdUFOW0IMAqk/ZOWGqEcWeGd5T\n",
       "uHYdeiP10GKrMxeCdxjjeUeIaBpxkXQ3KESM7wpk7sirjkUTRkPdCPRTJK0AAAAeAZ4WdEN/AAcT\n",
       "TaYSmyxQWchRRuTwLM1asC7Y3RLdAAAAHQGeGGpDfwAHP7WGgUVyFaqjcngWYMvtxKlrPgiAAAAA\n",
       "0kGaHEmoQWyZTAgj//61KoABVAjdpMAOV/EObN190HbXMpZncVMoxSCNtHz3X2wKAbYWGxR0Dmhh\n",
       "hhk6+F+SE5rJGacKAKRWD8xCxZO01liL6LR2gP/gP+PuvrwXEDLyFfSKJOczWo784a1yxBMnhV4D\n",
       "gaUuuHyIpBrcJ2lpPwmDx74RGtaO+3pCfdQN6ygTyBxMWOCLKgCn9wk7Acj35swzxyO9Qf0StqkM\n",
       "OL0JJjLXSl0mwFl7N08w2q3YM9sigVm1RFsmGglxtIdJHEINXt8woQAAAFNBnjpFFSw3/wA+KlVK\n",
       "B1BKKtgADyduoC8UBf38kqKUGqMeFKJm3ioFgYD/E4TzXsAPRmBJ9htpXNvw7f9ZWNnTH/2/Ygrw\n",
       "/e9Z6QkW4ZsfQY283AAAACEBnltqQ38ADdF2XhXY8gn9DiF8AH9DbHuj7fx5V0mr6mEAAAFQQZpA\n",
       "SahBbJlMCCP//rUqgAKF0b2Y/xyRjhgVgAsPuV33uwrynt1/uy7R8DnrnTkBzjuHUzRmmqADeY05\n",
       "0FYQANd0wsf/+4gABLx++cu0kZl92bN03/bVQ8t6b3DYc1BxGBl4+1LxKqXchQ6H0ga//bqei0hp\n",
       "EVC5lzYdfCLKhYAAwFDksJHum1cPvILptChJlclL6BZ516ewuWF8iHKljwRcbXXhuo5Fu7+1rZ/1\n",
       "bn7bF8VGccKPGG0FgE5oCuulBntRW5ajTuX8AtgLFcLPnJ+9Fgv/f3nVBQyo28Qotzc97lJCKjKl\n",
       "kB/yQ+1OLVlf3dcTwd5yrYr1GdilnAyjM/niNqj3kFc9w3jD04wLosNNIa37upJb3BAgA9kAuL98\n",
       "pC/u0T6oJrM+QO8vj2cX8l56QKxEN1M48ZRKiiMYHfDlzDlmstDjByXP66EwghZ3AAAAqkGefkUV\n",
       "LDv/ACyuGCiBm/+ZABEGGz/kIAwEXDgeCl1uTvWCIFQHBvbkchJ4iMlLYGFPfC+s9MRwsGDtoqbM\n",
       "555IOsqAUjg0WZTeMGdft5yq58Cj7sNWMsbRpJr7NnD8je5TpBEC+BArm7qAri6z8g5SUg9Ve8KD\n",
       "H4BCUbXgLq/hBrAkwDEMyTnZFqb+aSyCOErBAp6d8l40Mhi7N8jqsb8+rm2kyuCZVwKuAAAAGgGe\n",
       "nXRDfwANz1f0T9AeuZ/VzXxhD2Bb1TdAAAAAJQGen2pDfwAG6LpsYr7Kcie+sLbV+crlQAcsAjxg\n",
       "XN2ulq3ozJ8AAAFCQZqESahBbJlMCCP//rUqgAFBJ+kAFh9zFrQOxG2701/k/gVbfvIi1f7swzsb\n",
       "gYc28GVvab6mAakWF3z4jxXCmcuzj8GdVDE1EiKkTkYwC+qA34hXV+vN9Z7RktJ5HGzn/4O1MMyW\n",
       "1IahOgtM+4KZGYF0Y/Yuf9yRDikzkY8KqEIJgsmEwYRyFLkThcARLPA26uQNU/PcribY5n0CaDeN\n",
       "NRLHEX8IIO8ysx4CvpFEQp9LS2QI48J7Qv7Bv+FskdXF0HaeRqTr9jmWKVrfdwwKTfHKYXFp9Y6O\n",
       "KDf3sj8VxhYyTfh4OX/GUKUeq+kW+TdlBy49/RqYtpE0Q8HC9rfro/mnXtMyJAm3T3rYgslXdwhG\n",
       "47NqJYsM9t6eRNITE4EwvptApoHSwlZNY4Vccn5J1Vy84AJvwjP+3s3U/8qA0lbAAwAAAKJBnqJF\n",
       "FSw7/wAsrhgeAMhCjiMhUQAcIwP2wSxZkWAE3X6eZ7ci4ILrcillkhObfx+UW+CuABmBXBAnGDZn\n",
       "JqGYLIDJ6ZEowfMEWZM5iIwt2Q6sStEIVhi8eRp2uOcGddeEsn8PcaqcjZmwULZpWvv1vQvCstH2\n",
       "fV57TdfWPDMuGKSQtYEXzhg5NorDsGh7apk6uq08bG5rRgDO0OrVHbxjC6UAAAAbAZ7BdEN/AAbp\n",
       "CZsW9s40aDb9tJ16wb+F1YKAAAAAHQGew2pDfwADdF0mKCFtudeDMsEaR8Dus/wlt2FhAAABIUGa\n",
       "yEmoQWyZTAgj//61KoABOQRp6lABLmrE7DUFWKZ1gKD/1bIxdwUyitSU9cvXtL3zRPIqtlSI5oIn\n",
       "DsawJ6lkBdL3R51dk8nDFWAjcpyJpAwxftc6x3udULKK6k5KPIs3t9C3z5P1XRvYlLPoe1W7hYlu\n",
       "GV+PxemhOMbM8qx5yOcVavkNfGAx0zywHkdRU1DpQ02JxB1rSgmbyGcDwnfq2Oq/hq37NoquCC2+\n",
       "Bh6wMLuveNNh52lbf1VsoZf/NDPfa/J5vLlIqhLA2Zt6vxOWtEvFa2ChRPMX2rNrALoxCym2vE3p\n",
       "YmClJURIQtuRdmKTgTMebp7bJ9mRQ8pZUnWsyFaH2vYtsoiB2y5pM3YyDszJ0tIy/Nn5WkSKTDOO\n",
       "Z4EAAACjQZ7mRRUsO/8ALK4YJ2esTJzGgBOtKEhdYxdAntuX5qh6U9RhUf/WUVnnohvy0fMYme6U\n",
       "H22WSbT6xbez2Y9JU/C/+qkAKHa1PXLCHqvpXmQcgcuz/Qv9PxV/mEfZklEvWHUg0rWeAhIn7a2X\n",
       "sCAd75UZPXMkOj/UAkD27zXGm9hIIzf+iHVH9CcesKoWQr1uEPYZhPpv54QWKt/DjhUmF8OIKQAA\n",
       "ABwBnwV0Q38ABsEJmvSCOV+teo2Ai7+0mNm5iTthAAAAHQGfB2pDfwANMXZeFdjzPduvED6qnNRD\n",
       "KWTziz1LAAAA4EGbCkmoQWyZTBRMEf/+tSqAATiDFPaIg/QAhNP+EnYFx3fpKgK9JNhp/+KwhP/m\n",
       "nb4K+10+g00ZucVUTRn/1ocS458/At9L+gUhHU0hhSz3zyEI0ySv9seU2lY8cpJSt7B76O3gIT1O\n",
       "ZTD+RtST0R3lDXgM3tUY4gtg5aiZ1f3ENJ7g4vLd3dMkNy4H6IXKIFmNIu6XJsng/EKxsE83KfsA\n",
       "l9F2J2JHRHybEOFPtpk/2mCDwLtUR/lDFYfKIfXQ32fz+bXHE+B4En041spYhZ5HsNtN5Eu1ZnTu\n",
       "9B54QZ5uAAAAHQGfKWpDfwA+KlVYGpd+yP/Qi7Y4mdbsKBdQa1rhAAAA20GbLUnhClJlMCCP//61\n",
       "KoABMC1mueDjfDPEHogAqT3MWavk+hN9uHriYfGE2o9izbcnMA90+eRbOZSwo7no+tfxmDVonueo\n",
       "f87kPvlqb+7OfsrLSe2fKzhJ+Z+EQWUHns+YxEtWF5XaMB4UZZtqKJ7ZRPLaeVZAHmK6D45zC5Uw\n",
       "ln0gF2TgOMG+FhPq+1njY0zix5bfEEaBnPzM5LJkQn5lhG4t3KRlP/DQFogh+G9tVRGC+wCxajnG\n",
       "lkdXiyIwy8OGGwnARQSMbKliqXfeNnr3SR0i3W96BpnawAAAAE1Bn0tFNEw3/wA+J886ZFcnRlEp\n",
       "twnXqN/NpoAPQfYxy+DMqSWav7wb+NYl6dyNuj5Jilzptn4svGmCk8Uaiwe80uURgyqtR05XmxRj\n",
       "GAAAABYBn2xqQ38ADTF2CwgSdZVsNJ2p97mxAAAArEGbcEmoQWiZTAgj//61KoABMf9O0AG1CjWN\n",
       "v/ayjcFRkKqKC1q2BnvfS3DCOKD1MLcfA18ewKgktpjL6dp5DpydUKxh/cQw7jkEKaQQL05ZWBuE\n",
       "15AQMRPITXUkZbk3mBJAMG2zgr7iNN/7zC8oRnhoBTubRNYTNFwgCS6zB6V9MK+/lxmJgB48M13P\n",
       "gmOIhC3AhEDGLgTHx4TV5FsgOpMneMO1JV5+D8hzTLkAAABAQZ+ORREsN/8APipVWA76JrK4HQVz\n",
       "P4ATJ6pFbc9etT0Dsdsm6ZXd0R3dhqgal8UwYKDqKS2XQo2IIaJlavnmgQAAAB8Bn69qQ38ABofK\n",
       "wTsnggoaANzWDjPUc4ep5pENyUXuAAABJ0GbtEmoQWyZTAgj//61KoABMETM1FY8u5IU+yqoyAAW\n",
       "8zZhDpgojh35e91sjbmrd1fK5NNswsThgNGxCtL2VZPQCF9WbnRQtn/8f8yQNKpiNPSiNXfF4d8X\n",
       "ROa6cYZIOVVHfYi498Yc8a4H05SXCcGAejs3XJQh+ANhLi/FspgXcl7BTznzsM/ejJWJ2Hf4Ep4y\n",
       "GM+LhEhfUpqKyeSPxmTckdEWAMcHusVJP7GvwuZCtmctxtVPegJxvk4xHu5nMAHqH6qO/R6wEkwh\n",
       "lL1DL2/idGMUta76ibFIRUovpIrdm0lv98sONaJTXirqKxgMFEk9X+Vqb/+HuuCY66v6X6dSXfR+\n",
       "XhEkzF3QPDg4bKNABjDkV6uSFzGsLWPXmg7F/dFILnnFjjMAAABIQZ/SRRUsO/8ALK4YHXDJsEIH\n",
       "EYjZ6Vku/QAg2wkMbPXZ8bTq8MPSGBZRQbu4eafu2haEkqszorekLrMxFU+yAbfPP9ZW5+tlAAAA\n",
       "GgGf8XRDfwAGl6wXjBhslQnWI2cU5VEtWFKQAAAAJQGf82pDfwADOF2EbL/L9ZTNcSndZskAH7z6\n",
       "HGUD+nFinXYffGQAAADTQZv2SahBbJlMFEwR//61KoABKdLn/jS2YAOLYFUGaVdb2/zVyuHoN8Oz\n",
       "7T3apC/9fM0AOo1wwYZ1dn6FUckjiGi2LXBBGYEYTSEOtWDD5NuLiCl9RO8i93CvxrOgtfeKNO4j\n",
       "k+zhwNjKIrRV+/Or6Jvr3rJ7nBlfCBr923x5dQOmVdbTr6pQLLyUHN2QBEmyZP6FCFP958Cvi7iS\n",
       "a35WRrbE6lBngZOgSVasLZmx89WtTUfyihuSjfvtTu7U4osmY5Z1+xH3bJv2FpW/oTpqqgnXQQAA\n",
       "ADQBnhVqQ38APipVR6L3wLqD5M1FD/WDqicUB/Smul2whVJAB+8+hxlOfVSd9H6K4YzNDLaAAAAA\n",
       "pkGaGknhClJlMCCP//61KoACUFvVig5ezRxAFT9jt9dKwlfX9+p+nRLSVLdC4RB0D3RRRx8D57Ra\n",
       "8eNvlBEuYYIQIvuQ6nxYhPIQo0SizYqOxN82td8txwk8gDDd7Nem6SqTbcg/3BhJlr9fYgVhJG0H\n",
       "BWr3ttj2dKbN6jWqvvcrjq8wtbiegm8kfj7gzFtF3BYKCeywkNiEObP6gUvIdwJWY+yTSCEAAABj\n",
       "QZ44RTRMO/8ALKxcJtrrMzbi4AEEeurqO1FVRorXIZPh191tP2VWFEX9fsF1jOqWYcgC+wpb3Mc8\n",
       "SQAgCnk6kZvvMsDdLwB+z7cfxZAAAWP1z/cNG+PJqLcijyd4zIxRKZLrAAAAGQGeV3RDfwAGcQqS\n",
       "Mq25Xekh0wdwNg74kGAAAAAcAZ5ZakN/AAzhdhGyhOv2Qu8bAY/Dxx1PftvezQAAANdBml5JqEFo\n",
       "mUwIIf/+qlUACUPaGzo4AII/wXli/N1DzmY2KM/kI3zp/iUYgoayrWWL5XF4fmBI+71TyHWU5Awh\n",
       "7iyzRLuQKvEyPPoqb//9Gw+9DB9SReruBphdPVYt6zsiT2iE12dhIWMI+fsFOmmn4syJnWwOe5ZR\n",
       "kfFSuKSXOzIyyxZyrkCgydr8LSYhQC4Pj7zr+ft9aedE+CZkQfwolBHXkGMELp4b8UsYfR91Mz+p\n",
       "i5FViZPFrkWD5E6HUPZYgVuK4St+CzsmwjQ/tTQHyYhnv3OmuAAAAFRBnnxFESw7/wAsrhg6N0aJ\n",
       "Z0RNYAQh59AjTrwhF/fHkRxDcwN0i4NcJBgcBqS1gA7z5lEaNMBQuxPZJDb7KML6586EOi0WJuXZ\n",
       "Y873RLPP8cYrz2kAAAAeAZ6bdEN/ABnEKkjHCfhkGl4rufwoMto/iiu8k6thAAAAIwGenWpDfwAZ\n",
       "wuwjZMKC/pKrBoVC8VVp6AJxnLRu9kHx4PNgAAAAvkGagEmoQWyZTBRMEP/+qlUACYC4GqTPDEKz\n",
       "G6GACMrhR1KmHJVQwgiYvDkI2Q4+12owz0egBhoL7Dxz/7VR6Vj6Ch+T+8MD14smMA/0Q6s4dRLt\n",
       "Kyifn0xuh2jCMb/0aTujcWL6vsVFmSgwimFeT8eTs1lo05PuT6b5kv219HAQvgA18j+gBXRpMmae\n",
       "zqpeLEj6Fq2aKQfRl+Xc/VKka22bl4h1qwayD465Rx9N+3q8KdaEIVhuaCNod5+KZ1AAAAAhAZ6/\n",
       "akN/AD4qVXgrRs8CpLpYwf4XrQq7k42KcSiPgatHAAAA3UGapEnhClJlMCG//qeEAEl/PPqhKO3n\n",
       "poALZPZs003Hc8BNgwVh4H6sFnPp87P/x8h4AcNbJR4OaGA55KbxjVHg2vsFZPhQGfkfLtQ6DdF0\n",
       "6BNEpf/CiYnt4Gg7lWuvMvm5iLlXqJXGm3+Kr/PzEHGZ7uxq24o6pPt7CrnqK2dgIfNcEOdf1Tq7\n",
       "kj5p7DXBaqQBtlcMuFoz9rCa7fw646O15emtBF8wnplsgXtoL38770L0E+hzJIvaN+jYkP3KJE5d\n",
       "laJ29/FV87W/bqa3LbMLWhXAvoyePTLJdjm8AAAApkGewkU0TDv/ACysXQla60RGADarWyhBqsWj\n",
       "o5k065jf7hgABrMn6sA+WWrGeFh8uIkqIg3jos1jv4TSh/tUL1BkLXMaUzAKv59vdnQWC2RFrA3n\n",
       "6xJ8bT4i2Zp04EWZC+LGyHe7GUjrwWaLCR825Tsj4vxcdAki4CCAvEJCHYfBp76z4XrWyLJHMXv7\n",
       "VsCc3tbUc2obflfDV7ZwdtUDLKt5VfR8T0EAAAAjAZ7hdEN/ADTIVJFvnBuwMMgzBOhVmCNPQ7Ys\n",
       "1iCUNjiI+fAAAAA8AZ7jakN/ADTKaxayWghqJx72WRfAsrxMAEmUaRkSYyAE0vdKMkfLzbPPbF40\n",
       "6TBz+ZFOAfwz7WWGVLFBAAAJLm1vb3YAAABsbXZoZAAAAAAAAAAAAAAAAAAAA+gAADP0AAEAAAEA\n",
       "AAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAA\n",
       "AAAAAAAAAAAAAAAAAAAAAAIAAAhYdHJhawAAAFx0a2hkAAAAAwAAAAAAAAAAAAAAAQAAAAAAADP0\n",
       "AAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAGwAAAB\n",
       "IAAAAAAAJGVkdHMAAAAcZWxzdAAAAAAAAAABAAAz9AAACAAAAQAAAAAH0G1kaWEAAAAgbWRoZAAA\n",
       "AAAAAAAAAAAAAAAAKAAAAhQAVcQAAAAAAC1oZGxyAAAAAAAAAAB2aWRlAAAAAAAAAAAAAAAAVmlk\n",
       "ZW9IYW5kbGVyAAAAB3ttaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAA\n",
       "AAAAAAEAAAAMdXJsIAAAAAEAAAc7c3RibAAAALdzdHNkAAAAAAAAAAEAAACnYXZjMQAAAAAAAAAB\n",
       "AAAAAAAAAAAAAAAAAAAAAAGwASAASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n",
       "AAAAAAAAAAAAABj//wAAADVhdmNDAWQAFf/hABhnZAAVrNlBsJaEAAADAAQAAAMAUDxYtlgBAAZo\n",
       "6+PLIsD9+PgAAAAAHHV1aWRraEDyXyRPxbo5pRvPAyPzAAAAAAAAABhzdHRzAAAAAAAAAAEAAACF\n",
       "AAAEAAAAABRzdHNzAAAAAAAAAAEAAAABAAAD+GN0dHMAAAAAAAAAfQAAAAEAAAgAAAAAAQAADAAA\n",
       "AAABAAAEAAAAAAEAAAwAAAAAAQAABAAAAAABAAAUAAAAAAEAAAgAAAAAAQAAAAAAAAABAAAEAAAA\n",
       "AAEAABAAAAAAAgAABAAAAAABAAAQAAAAAAIAAAQAAAAAAQAAFAAAAAABAAAIAAAAAAEAAAAAAAAA\n",
       "AQAABAAAAAABAAAUAAAAAAEAAAgAAAAAAQAAAAAAAAABAAAEAAAAAAEAAAwAAAAAAQAABAAAAAAB\n",
       "AAAUAAAAAAEAAAgAAAAAAQAAAAAAAAABAAAEAAAAAAEAAAwAAAAAAQAABAAAAAABAAAUAAAAAAEA\n",
       "AAgAAAAAAQAAAAAAAAABAAAEAAAAAAEAABQAAAAAAQAACAAAAAABAAAAAAAAAAEAAAQAAAAAAQAA\n",
       "EAAAAAACAAAEAAAAAAEAABQAAAAAAQAACAAAAAABAAAAAAAAAAEAAAQAAAAAAQAADAAAAAABAAAE\n",
       "AAAAAAEAAAwAAAAAAQAABAAAAAABAAAMAAAAAAEAAAQAAAAAAQAADAAAAAABAAAEAAAAAAEAABQA\n",
       "AAAAAQAACAAAAAABAAAAAAAAAAEAAAQAAAAAAQAAFAAAAAABAAAIAAAAAAEAAAAAAAAAAQAABAAA\n",
       "AAABAAAUAAAAAAEAAAgAAAAAAQAAAAAAAAABAAAEAAAAAAEAABQAAAAAAQAACAAAAAABAAAAAAAA\n",
       "AAEAAAQAAAAAAQAAEAAAAAACAAAEAAAAAAEAABAAAAAAAgAABAAAAAABAAAMAAAAAAEAAAQAAAAA\n",
       "AQAAFAAAAAABAAAIAAAAAAEAAAAAAAAAAQAABAAAAAABAAAUAAAAAAEAAAgAAAAAAQAAAAAAAAAB\n",
       "AAAEAAAAAAEAABQAAAAAAQAACAAAAAABAAAAAAAAAAEAAAQAAAAAAQAAEAAAAAACAAAEAAAAAAEA\n",
       "ABQAAAAAAQAACAAAAAABAAAAAAAAAAEAAAQAAAAAAQAAFAAAAAABAAAIAAAAAAEAAAAAAAAAAQAA\n",
       "BAAAAAABAAAUAAAAAAEAAAgAAAAAAQAAAAAAAAABAAAEAAAAAAEAAAwAAAAAAQAABAAAAAABAAAQ\n",
       "AAAAAAIAAAQAAAAAAQAAEAAAAAACAAAEAAAAAAEAABQAAAAAAQAACAAAAAABAAAAAAAAAAEAAAQA\n",
       "AAAAAQAADAAAAAABAAAEAAAAAAEAABQAAAAAAQAACAAAAAABAAAAAAAAAAEAAAQAAAAAAQAAFAAA\n",
       "AAABAAAIAAAAAAEAAAAAAAAAAQAABAAAAAABAAAMAAAAAAEAAAQAAAAAAQAAFAAAAAABAAAIAAAA\n",
       "AAEAAAAAAAAAAQAABAAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAIUAAAABAAACKHN0c3oAAAAAAAAA\n",
       "AAAAAIUAABEIAAAB8QAAADcAAAC0AAAAHAAAAX0AAABrAAAAJgAAABwAAAFTAAAAZAAAAB0AAAD4\n",
       "AAAAawAAABoAAAEBAAAAmAAAABsAAAAlAAABCgAAAG0AAAAZAAAAGwAAAN8AAAAaAAABDgAAALcA\n",
       "AAApAAAAHgAAAQ8AAAAeAAABWAAAAFwAAAAeAAAAGgAAAP8AAAB/AAAAGQAAABcAAAFfAAAASQAA\n",
       "ABkAAADnAAAAlQAAAC0AAAAaAAAAhQAAAB0AAAD2AAAAIAAAAPYAAAAgAAAAzwAAABwAAAFFAAAA\n",
       "owAAAB4AAAAeAAAA7wAAAGYAAAAZAAAAGAAAARwAAACuAAAAGQAAABoAAAEtAAAAjwAAACAAAAAc\n",
       "AAAAwwAAAE4AAAAaAAAA+wAAAEcAAAAbAAAA3gAAAB8AAADLAAAAkgAAABkAAAAiAAABKwAAAKcA\n",
       "AAAgAAAAJAAAAQIAAACwAAAAIgAAACEAAADWAAAAVwAAACUAAAFUAAAArgAAAB4AAAApAAABRgAA\n",
       "AKYAAAAfAAAAIQAAASUAAACnAAAAIAAAACEAAADkAAAAIQAAAN8AAABRAAAAGgAAALAAAABEAAAA\n",
       "IwAAASsAAABMAAAAHgAAACkAAADXAAAAOAAAAKoAAABnAAAAHQAAACAAAADbAAAAWAAAACIAAAAn\n",
       "AAAAwgAAACUAAADhAAAAqgAAACcAAABAAAAAFHN0Y28AAAAAAAAAAQAAADAAAABidWR0YQAAAFpt\n",
       "ZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0b28A\n",
       "AAAdZGF0YQAAAAEAAAAATGF2ZjU4LjQyLjEwMA==\n",
       "\">\n",
       "  Your browser does not support the video tag.\n",
       "</video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TronGame.view_game(game_histories[0])\n",
    "# print(winner_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 360
    },
    "colab_type": "code",
    "id": "yMXZKQI7pt9Y",
    "outputId": "3b76d733-a1ff-417c-f81f-28512d0e9976"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "TRON (2).ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
